dcProfile := map[string]string{
  "name": "Daniel Caballero",
  "title": "Staff Devops Engineer",
  "mail": "dani(dot)caba at gmail(dot)com",
  "company": &SchibstedPT,
  "previously_at": []company{&NTTEurope, &Semantix, &Oracle},
  "linkedin": http.Get("https://www.linkedin.com/in/danicaba"),
  "extra": "Gestión DevOps de Arquitecturas IT@LaSalle",
}

{
    "format": "jpg",
    "watermark": {
        "location": "north",
        "margin": "20px",
        "dimension": "20%"
    },
    "actions": [
        {
            "resize": {
                "width": 300,
                "fit": {
                    "type": "clip"
                }
            }
        }
    ],
    "quality": 90
}

reviewersRaffle:
  strategies:
    - team-with-knowledge-candidates:
        size: 1
        type: knowledge
        participants:
          teams:
            - spt-infrastructure/edge-team
    - team-random-candidates:
        type: sequential
        size: 2
        participants:
          teams:
            - spt-infrastructure/edge-team
  dailyReminder: enabled
slack:
  - "#spt-edge-prs"

language: go
go:
- 1.9.3

script:
- diff -u <(echo -n) <(gofmt -s -d $(find . -type f -name '*.go' -not -path "./vendor/*"))
- docker login -u="$ARTIFACTORY_USER" -p="$ARTIFACTORY_PASSWORD" containers.schibsted.io
- "./requirements/start-requirements.sh -d"
- "_script/tests-docker"
- "_script/compile-docker"
- "_script/cibuild"

deploy:
  skip_cleanup: true
  on:
    all_branches: true
  provider: script
  script: _script/deploy

fpm -s dir \
    -t rpm \
    -n ${PACKAGE_NAME}${DEV} \
    -v ${VERSION} \
        --iteration ${ITERATION} \
    --description "Yams delivery images. Commit: ${GIT_COMMIT_ID}" \
    --before-install ${TRAVIS_BUILD_DIR}/_pkg/stopservice \
    --after-install ${TRAVIS_BUILD_DIR}/_pkg/postinst \
    --before-remove ${TRAVIS_BUILD_DIR}/_pkg/stopservice \
    --depends datadog-config \
    --depends sumologic-config \
    ${DIST_PATH}/${PACKAGE_NAME}/=/

  pre:
    not_allowed_notify_to:
    - "@webhook-alert-gateway-sev2"
    - "@pagerduty"
    healthy_host_count_critical: 0.0
  pro:
    healthy_host_count_critical: 1.0

monitors:
  - name: "[ALB] - {{name.name}} in region {{region.name}} - 5xx backend error rate"
    tags:
      - "app:yams"
    type: "metric alert"
    options:
      require_full_window: false
      thresholds:
        warning: 0.05
        critical: 0.1
      notify_no_data: false

n := negroni.New(recovery)

n.Use(NewRequestIdHandler())
n.Use(tracing.NewTracingHandler())
n.Use(negroni.NewStatic(http.Dir(serverConfig.schemaDir)))

loggingMiddleware := negronilogrus.NewMiddlewareFromLogger(serverConfig.log, "bumblebee")
loggingMiddleware.SetLogStarting(false)
n.Use(loggingMiddleware)

n.Use(statsMiddleware)
n.UseHandler(httpRouter)
return n

if transformedImage.FromCache {
    b.Logger.WithField("id", requestId).Debug("Found Transformation in cache")
    tracing.AddLogToSpanInContext(request.Context(), "Got image from cache")
    b.Monitor.Incr("transformation.cache.hit", tags, 1)
} else {
    b.Monitor.Incr("transformation.cache.miss", tags, 1)
    transformationElapsed := time.Since(transformationStart)
    transformationElapsedInMillis := float64(transformationElapsed.Nanoseconds()) / 1000.0
    b.Monitor.TimeInMilliseconds("request.transformation.duration", transformationElapsedInMillis, tags, 1)
    b.Monitor.Gauge("request.transformation.duration", transformationElapsedInMillis, tags, 1)
    b.Logger.WithField("id", requestId).Debug("Transformation took: ", transformationElapsed.Seconds(), " secs")
    tracing.AddLogKvToSpanInContext(request.Context(), "transformation.duration", transformationElapsed.String())
}

viper.SetDefault("eureka.datacenter", amazonDatacenterInfo)
datacenter := viper.GetString("eureka.datacenter")
if datacenter == k8DatacenterInfo {
    var err error
    appInstance, err = sdeureka.NewK8SFargoInstance(eurekaConfig)
    if err != nil {
        return nil, nil, err
    }
} else if datacenter == amazonDatacenterInfo {
    awsSession, err := session.NewSession()
    if err != nil {
        log.Info("registerEureka", "error creating an AWS session", "message", err)
        return nil, nil, err
    }

    instanceMeta := ec2metadata.New(awsSession)
    appInstance, err = sdeureka.NewAwsFargoInstance(log, eurekaConfig, instanceMeta)
    if err != nil {
        return nil, nil, err
    }
} else if datacenter == localDatacenterInfo {
    var err error
    appInstance, err = sdeureka.NewLocalFargoInstance(eurekaConfig)
    if err != nil {
        return nil, nil, err
    }

hystrix.ConfigureCommand("DeliveryImages#GetWatermarkFromLogicManager", hystrix.CommandConfig{
    Timeout:               viper.GetInt("hystrix.command.DeliveryImagesGetWatermarkFromLogicManager.timeout"),
    MaxConcurrentRequests: viper.GetInt("hystrix.command.DeliveryImagesGetWatermarkFromLogicManager.maxConcurrentRequests"),
    ErrorPercentThreshold: viper.GetInt("hystrix.command.DeliveryImagesGetWatermarkFromLogicManager.errorPercentThreshold"),
})

hystrix.ConfigureCommand("DeliveryImages#GetResourceByAliasFromTranslator", hystrix.CommandConfig{
    Timeout:               viper.GetInt("hystrix.command.GetResourceByAliasFromTranslator.timeout"),
    MaxConcurrentRequests: viper.GetInt("hystrix.command.GetResourceByAliasFromTranslator.maxConcurrentRequests"),
    ErrorPercentThreshold: viper.GetInt("hystrix.command.GetResourceByAliasFromTranslator.errorPercentThreshold"),
})

func httpServer(serverConfig deliveryImagesServer) *negroni.Negroni {

    httpRouter := httprouter.New()
    httpRouter.GET("/tenants/:tenant_id/domains/:domain_id/buckets/:bucket_id/images/*image_id", serverConfig.bumblebeeController.Handler)
    httpRouter.HEAD("/tenants/:tenant_id/domains/:domain_id/buckets/:bucket_id/images/*image_id", serverConfig.bumblebeeController.Handler)
    httpRouter.POST("/schema/validate", serverConfig.schemaController.Handler)
    httpRouter.GET("/healthcheck", serverConfig.healtcheckHandler)

    hystrixStreamHandler := hystrix.NewStreamHandler()
    hystrixStreamHandler.Start()
    httpRouter.GET("/hystrix.stream", hystrixStream(hystrixStreamHandler))

imageType := bimg.DetermineImageType(imageToTransform.Buffer())

tracing.AddLogToSpanInContext(transformationRequest.Context, "Imagetype: "+bimg.ImageTypeName(imageType))

autoRotate := getAutoRotateFromRule(rule)
if autoRotate {
    err = imageToTransform.AutoRotate()
    if err != nil {
        t.Log.WithField("id", transformationRequest.RequestId).Errorf("Failed to apply autorotation. Error: %v", err)
        return TransformedImage{}, err
    }
}

imageToTransform, err = t.applyBlurring(imageToTransform, transformationRequest)
if err != nil {
    t.Log.WithField("id", transformationRequest.RequestId).Errorf("Failed to apply blurring. Error: %v", err)
    return TransformedImage{}, err
}

if err = t.applyPixelation(imageToTransform, transformationRequest); err != nil {
    t.Log.WithField("id", transformationRequest.RequestId).Errorf("Failed to apply pixelation. Error: %v", err)
    return TransformedImage{}, err
}

func (t *VipsTransformer) applyPixelation(imageToTransform *bimg.SchImage, transformationRequest TransformationRequest) error {

    if len(transformationRequest.Rule.GetPixelateAreas()) == 0 {
        return nil
    }

    start := time.Now()
    pixelAreas := make([]bimg.PixelateArea, len(transformationRequest.Rule.GetPixelateAreas()))

    for i, pixelArea := range transformationRequest.Rule.GetPixelateAreas() {
        pixelAreas[i] = bimg.PixelateArea{
            Left:          pixelArea.Left,
            Top:           pixelArea.Top,
            Width:         pixelArea.Width,
            Height:        pixelArea.Height,
            MinNrOfPixels: pixelArea.MinNrOfPixels,
            MinPixelSize:  pixelArea.MinPixelSize,
        }
    }
    defer t.metrics("pixelate", transformationRequest.Context, transformationRequest.RequestId, start)
    return imageToTransform.Pixelate(pixelAreas)
}